home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Fritz: All Fritz
/
All Fritz.zip
/
All Fritz
/
FILES
/
BUSINESS
/
ZIPKEY.LZH
/
ZPROG.DOC
< prev
Wrap
Text File
|
1990-10-15
|
32KB
|
791 lines
PROGRAMMATIC INTERFACE DOCUMENT
This file is intended for computer programmers who wish to access
ZIPKEY directly from within their programs. If you are not a
computer programmer, you may ignore this file.
The ZIPKEY Interrupt
When ZIPKEY is installed as a memory-resident program (using the
ZIPKEY 4 command), it takes over one of the 8086's interrupts,
INT 179 (decimal; it's B3 in hexadecimal). This interrupt serves
two functions: first, it is the method by which ZIPKEY detects if
it has already been installed. Second, it provides the interface
by which computer programs can call ZIPKEY directly, to obtain
zipcode-related services.
I conducted a survey of numerous computers before selecting INT
179 to be used by ZIPKEY. I found no computers or peripherals
that use this interrupt, and I am hopeful that there are none.
If your computer does use INT 179, then ZIPKEY and the device or
program using INT 179 will interfere with each other. You can
change the interrupt number ZIPKEY uses by modifying the ZIPKEY
program itself: the number 179 is stored in the fourth byte of
the ZIPKEY program code, immediately beyond the three-byte JMP
instruction that begins the program. This JMP occurs at the very
start of the ZIPKEY.COM file, or immediately beyond the 512-byte
header of the ZIPKEY.EXE file. You can use a debugger or a hex
editor to modify the byte to an unused interrupt number.
Testing for ZIPKEY's Presence
Before you program attempts to call ZIPKEY, it may wish to verify
that ZIPKEY has been installed, and report an error if it isn't.
Otherwise, you program may crash when it tries to call code that
isn't there.
You can test for ZIPKEY's presence by examining the INT 179
handler, whose doubleword pointer is stored at offset 179*4 (=716
=02CCH) within segment 0 of the 8086 memory space. If ZIPKEY is
installed, the doubleword points to its code segment. Location
075H within that code segment contains the signature string
ZIPKEY. Thus, the following code sequence will check for
ZIPKEY's presence:
P-2
OUR_ZIPKEY: ; our copy of the template
DB 'ZIPKEY'
CHECK_FOR_ZIPKEY:
PUSH DS ; save register value
SUB AX,AX ; load zero
MOV DS,AX ; point DS to 0 -- 8086 interrupts
MOV DS,WORD PTR 02CEH ; fetch the segment part of INT 179
MOV SI,075H ; point to signature in segment
PUSH CS ; push our code segment
POP ES ; set ES to our code segment
MOV DI,OFFSET OUR_ZIPKEY ; now ES:DI points to 'ZIPKEY'
MOV CX,3 ; there are 3 words in 'ZIPKEY'
REPE CMPSW ; does DS:75H point to 'ZIPKEY'?
POP DS ; restore register before jumping
JZ ZIPKEY_INSTALLED ; jump if it does match
ZIPKEY_NOT_INSTALLED: ; it does not match
Following the ZIPKEY signature, at offset 07BH within the ZIPKEY
code segment, is a single byte that is zero in the initial
version of ZIPKEY, but will increment each time I release a
ZIPKEY with new features or any other changes to the programmatic
interface. That way, if you program needs ZIPKEY to be of a
sufficiently recent version, it can ensure that it is. (You can
also use the version number returned by the ZK_VERSION function
described shortly.)
ZIPKEY Calling Conventions
ZIPKEY's interface works similarly to that of the MS-DOS
operating system, or the LIM-EMS specification. The interface is
specified in 8086 assembly language. You load a function number
into the AH register, and possibly other input parameters into
other registers, then you execute an INT instruction with an
appropriate interrupt number -- in ZIPKEY's case, the INT 179
instruction.
When ZIPKEY has completed the function, it returns control to
your program at the instruction following the INT 179. The
success of the call is indicated by the Carry flag: NoCarry (flag
= 0) indicates success; Carry (flag = 1) indicates failure. If
the Carry flag is set, AL is usually set to an error code (the
exceptions are those functions which, as mentioned in their
following descriptions, return the state code for a suggested
city). Here are the possible error codes:
0FDH is returned if ZIPKEY is busy. You will get this error only
if the program calling ZIPKEY had interrupted another
program which also happened to be in the middle of a ZIPKEY
call. ZIPKEY is not reentrant, so it must refuse calls in
this situation. If you think this interrupted-programming
scenario is possible, you should check for this possibility.
If ZIPKEY is busy, you should give the interrupted code a
chance to complete the ZIPKEY call, and try your call again
later.
P-3
0FEH is returned if you provided an illegal function number in
the AH register.
0FFH is returned if the searching function requested failed to
find a valid entry, or even a suggested value.
Here are ZIPKEY's register-preserving conventions: The AX
register is clobbered by an INT 179 call; but all other 8086
machine registers are preserved unless they are specifically
named as having return values. If a function returns an error,
such return registers may be clobbered even if they contain no
values in the return case. For example, the ZK_STCITY_ZIP
function returns values in BH, CX, and DX. Except for AX, all
other registers not mentioned are preserved (SI,DI,BP,DS,ES).
The BH, CX, and DX registers may be clobbered even if the search
fails (and Carry is returned).
The ZIPKEY Functions
Following are the functions available to you when ZIPKEY is
installed. For each function, you load the input registers with
the values indicated, then invoke INT 179.
The names of the functions (ZK_VERSION, ZK_ABBR_ST, etc.) have no
significance to ZIPKEY-- I present them merely as suggested names
if you wish to implement a library of calls; and also so that I
can refer to the functions by name.
ZK_VERSION: returns ZIPKEY version information.
In: AH = 070H
Out: AX = The ZIPKEY program version number, as shown when
ZIPKEY is invoked or the ZIPKEY window is popped up. AH
is the major version number (to the left of the decimal
point) and AL is the minor version number (to the right
of the decimal point). For example, for V1.0 the return
AX value would be hex 100.
CL = The number of states, (and territories, etc.) in the
current database. Each state is assigned an internal
numeric code by ZIPKEY, that is used by many of the
functions of ZIPKEY's programmatic interface. These
codes range from 0 to CL-1.
DX = The date of the current ZIPKEY.OVL database. DL is
the month, ranging from 1 for January to 12 for
December. DH is the year minus 1900; e.g., decimal 89
for 1989.
P-4
ZK_ABBR_ST: converts a two-letter abbreviation into a state
code.
In: AH = 071H
BX = The 2-letter ASCII abbreviation for the state, in
either upper- or lower-case. BL is the first letter and
BH is the second letter.
Out: AL = The ZIPKEY state code, suitable for input to other
ZIPKEY functions in this chapter.
AL = 0FFH with the Carry flag set if not found.
ZK_ST_ABBR: converts a state code into a two-letter
abbreviation.
In: AH = 072H
BL = The ZIPKEY state code, ranging from 0 through CL-1,
where CL is returned by ZK_VERSION.
Out: AX = The 2-letter ASCII abbreviation, upper case. AL is
the first letter and AH is the second letter.
The Carry flag is set if the input state code BL was
invalid.
ZK_ST_NAME: converts a state code into a full state name.
In: AH = 073H
BL = The ZIPKEY state code, as returned by ZK_ABBR_ST.
ES:DI points to the buffer to contain the returned state
name.
Out: The full state name is output to ES:DI-pointed memory. DI
is advanced beyond the output.
The Carry flag is set if the input state code BL was invalid.
P-5
ZK_ZIP_DIGITS: converts zipcode DXCH into a ASCII digits string.
In: AH = 074H
DX = The zip region, ranging from 0 to 999.
CH = The last 2 digits of the zipcode, from 0 to 99. Or,
if you want only 3 digits output, set CH to 255.
Out: The 5 ASCII decimal digits of the zipcode are output to
ES:DI-pointed memory. DI advanced beyond the output.
The Carry flag is set if DX was greater than 999.
NOTE this is not really a database function-- it is just
an unpacking function provided for convenience.
ZK_ZIP_ST: looks up the state code for zipcode DXCH.
In: AH = 075H
DX = The zip region, ranging from 0 to 999.
CH = The last 2 digits of the zipcode, from 0 to 99.
Out: AL = the ZIPKEY state code.
BX = the area code.
The Carry flag is set, and AL=0FFH, if the zipcode
region (the first three digits) is invalid.
Note: for speed, this routine does not check for validity
of the individual zipcode: it looks at only the zip
region and the state-exceptions list. If you wish to
check the validity of a zipcode, use ZK_ZIP_CITY instead.
P-6
ZK_ZIP_CITY: looks up the state and city for zipcode DXCH.
In: AH = 076H
DX = The zip region, ranging from 0 to 999.
CH = The last 2 digits of the zipcode, from 0 to 99.
ES:DI points to the buffer to contain the returned city
name.
Out: The ZIPKEY state code is returned in the AL register,
and the area code in the BX register. The
city name is output to ES:DI-pointed memory. DI is
advanced beyond the output. To ensure that the name does
not exceed a maximum width, you can set the width using the
ZK_RESTORE function. The Carry flag is set if the zipcode
was not found, with AL/DI set to the suggested state/city
if there is one. AL is set to 0FFH if there is no
suggested city.
NOTE that a previous call to ZK_ZIP_ST can and should be
made if you wish to suppress output for the not-found-but-
suggested case.
ZK_ZIP_KEYS: plays the back exit key BX for the entry with
zipcode DXCH.
In: AH = 077H
BX = The 16-bit BIOS keycode for a defined ZIPKEY alternate
exit key. This is the code returned in the AX register
after you call the keyboard service routine (MOV AH,0
followed by INT 016H). For example, the code for the F1
function key on a 100% IBM-compatible is 03B00H; add
0100H for subsequent function keys.
DX = The zip region, ranging from 0 to 999.
CH = The last 2 digits of the zipcode, from 0 to 99.
Out: If there is a failure with no suggested city, ZIPKEY
returns Carry to the caller. Otherwise, it returns
NoCarry, and the zipcode specification defined by the BX
exit-key is inserted into the BIOS keystrokes buffer, as if
a user had popped up the ZIPKEY window, typed in the
zipcode, and exited with the BX exit key.
P-7
ZK_STCITY_ZIP: looks up the zipcodes for a given state and city.
In: AH = 078H
BL = The ZIPKEY state code for the city to be looked up.
DS:SI points to the city-name specification. The
specification is a string of ASCII characters,
terminated by a carriage-return (0DH) if the complete
name has been given, terminated by a null (00H) if
ZIPKEY should match any city whose name begins with the
specification, whether or not that is the complete city
name. Letters in the string can be in either upper- or
lower-case. ZIPKEY will also unabbreviate the string,
as described in Chapter 2.
Out: ZIPKEY accumulates a list of all cities that match the
specification given. The list is sorted first
alphabetically by city name, then numerically by zipcode.
Each entry on the list is a range of zipcodes for a city
that matches the specification. If the first and last
zipcodes in the range are the same, the range consists of
just the one zipcode. If they are different, then they
both represent valid codes for a matching city. Any
zipcodes between the first and last may be either valid
zipcodes for the same city, or undefined zipcodes.
The capacity of ZIPKEY's matching-entries buffer is 50. If
there are more than 50 entries for the specification,
ZIPKEY will return a count of 51 entries. You may make
calls to ZK_CASE_ZIP to determine the entries returned, but
be aware that unless the complete count happened to be 51,
the list is incomplete. The only way to obtain the
complete list of entries is to extend the city-name
specification by adding one or more letters in all possible
combinations.
The zipcode range for the first entry is returned with this
call. To obtain the remaining entries, you make repeated
calls to ZK_CASE_ZIP. To obtain a readable display for
each entry, you call ZK_ZIP_CITY, ZK_ZIP_ST, and
ZK_ZIP_DIGITS.
The return register values are:
BH = The number of matching entries (Carry set if BH=0). If
ZIPKEY's entries-buffer overflowed, BH is set to 51 (see
the above discussion about capacity).
DX = The zip region (0 to 999) of the first entry.
CL = The value of the bottom two digits for the first
zipcode in the range.
CH = The value of the bottom two digits for the last
zipcode in the range.
P-8
ZK_CITY_ZIP: looks up zipcodes for a given city.
In: AH = 079H
BL = The ZIPKEY state code of the first state to be
searched.
DS:SI points to the city-name specification, just as in
ZK_STCITY_ZIP.
Out: ZIPKEY accumulates a list of zipcode ranges, just as in
ZK_STCITY_ZIP. With this function, however, if no matching
entries are found for state BL, then BL is incremented to
search in the next state. Searching continues until either
a match is found or the last state code is reached. If
there is no matching entry for the last state, ZIPKEY
returns AL=0FFH with the Carry flag set. This differs from
the city-only search that is initiated interactively from
ZIPKEY's popup window-- the interactive search cycles
around to the first state and continues looking from there.
To get a complete list of matching cities for all states,
you call this function first with BL=0, then repeat the
call with BL set to the previous returned AL+1, until you
get a failed find.
The return register values are:
AL = The ZIPKEY state code of the first matching state. AL
is set to 0FFH with Carry set if no state was found.
BH = The number of matching entries (Carry set if BH=0). If
ZIPKEY's entries-buffer overflowed, BH is set to 51.
DX = The zip region (0 to 999) of the first entry.
CL = The value of the bottom two digits for the first
zipcode in the range.
CH = The value of the bottom two digits for the last zipcode
in the range.
P-9
ZK_CASE_ZIP: fetches an entry from a previous ZK_(ST)CITY_ZIP
call.
In: AH = 07AH
BL = a case number, from 0 to BH-1, where BH is the number
returned by the last call to ZK_STCITY_ZIP or
ZK_CITY_ZIP.
Out: AL = The ZIPKEY state code for this entry. Note that this
is the same value for all entries returned by a given
call to ZK_STCITY_ZIP or ZK_CITY_ZIP.
DX = The zip region (0 to 999).
CL = The bottom 2 digits (0 to 99) of the first zipcode in
the range.
CH = the bottom 2 digits (0 to 99) of the last zipcode in
the range. CH = CL if there is only one zipcode.
ZK_SAVE: fetches values necessary to save ZIPKEY's context.
In: AH = 07BH
Out: BL = maximum number of characters for a ZK_ZIP_CITY city name.
BH = the ZIPKEY state code for the last city-name search.
BH = 0FF if there is no previous ZK_STCITY_ZIP or
ZK_CITY_ZIP call.
CXDX = internal codes identifying the last city search
This function is provided just in case somebody wishes to
incorporate ZIPKEY into a multitasking system, in which
more than one task might be using ZIPKEY. The task-
switching code must call ZK_SAVE, record BX,CX, and DX as
part of the task state, and feed those values to ZK_RESTORE
before restarting the task.
ZK_SAVE can also be used to read the current setting for
the maximum city width, returned in the BL register.
P-10
ZK_RESTORE: restores ZIPKEY's context from a previous ZK_SAVE call.
In: AH = 07CH
BL = the maximum number of characters for a city name.
BH = the ZIPKEY state code returned by a previous ZK_SAVE
call.
BH = 0FF if you are just setting the city width.
CXDX = internal codes returned by a previous ZK_SAVE call.
Out: Carry if BH,CX,DX are not codes which could have been
returned by a previous ZK_SAVE call
This function will be used most often to set the maximum
city width. It is also used in multitasking systems, as
described under the previous function ZK_SAVE.
ZK_POPUP: pops up a ZIPKEY window from a program.
In: AH = 07DH
BL = an index number if you wish to simulate the pressing of
a hotkey.
BL = 0FF for immediate popup with nothing played back after
a confirming Enter key.
Out: ZIPKEY takes action as if the hotkey indexed by BL has been
pressed. This typically includes popping up a window,
waiting for the user to type a zipcode specification, and
playing back an indicated sequence through the BIOS
keystrokes buffer. The values of BL are defined by the
listing of hotkeys available from the configuration editing
menu: BL=0 for the first hotkey, BL=1 for the second, etc.
If BL is not a valid index ZIPKEY pops up a window, then
plays back nothing if a confirming Enter is given (ZIPKEY
will play back alternate exit keys, however). ZIPKEY does
not return from this interrupt call until the window is
popped away-- then it returns NoCarry.
P-11
ZK_REGION_CITY: outputs the name of the primary city for a
zipcode region.
In: AH = 07EH
DX = The zip region, ranging from 0 to 999.
ES:DI points to the buffer to contain the returned city
name.
Out: AL = The ZIPKEY state code for the region if the region
exists. BX is set to the area code.
The name of primary city for this region is output
to ES:DI-pointed memory. DI is advanced beyond the output.
AL = 0FF with the Carry flag set if the region does not
exist.
ZK_SWITCH: enables/disables hotkeys and/or DOS recursion checking.
In: AH = 07FH
BL = a control code:
0 for turn off hotkeys
1 for turn on hotkeys
2 for no change, just return hotkey status
3 for toggle hotkey status
6 for disabling DOS recursion checking
Out: The activation of hotkeys is disabled/enabled/reported.
When a hotkey is disabled ZIPKEY ignores it, and it reverts
to its non-ZIPKEY functionality. AL is returned set to the
hotkeys status: 0 for off (disabled), 1 for on (enabled).
If BL=6, ZIPKEY's program interface
(INT 179) no longer checks
to see if DOS is busy and cannot be called. It is the calling
program's responsibility to insure that DOS can be called.
ZK_AREA_ST: Delivers the state associated with area code BX.
In: AH = 080H
BX = area code (decimal integer)
Out: AL = the ZIPKEY state code for the area code, if the area code
exists. DX is set to the first zip region associated with that
state, and CX to the number of zip regions until the last
region associated with the state. You must make CX subsequent
calls to ZK_REGION_CITY to find which regions are actually within
the state, and/or contain the area code wanted.
If the area code is Canadian, we return a special state code
that will be honored by ZK_ST_ABBR and ZK_ST_NAME, but the
region DX is set to 1000. If the area code does not exist,
we return Carry, AL=0FFH and DX=1001.
P-12
Sample Program Code
Following are fragments of assembly-language code that call
ZIPKEY's programmatic interface. I've tried to make them
compatible with all the major assemblers, although they are
tested only against my A86 assembler. If you do use my A86
assembler, and you reuse the local labels L3, L4, L6, L8, and L10
elsewhere in your program, you should insert ">" into their
forward references in the following code: JC >L3; JC >L4; JMP
>L6, JNE >L8, JE >L10.
RO_NAME:
DB 'RO',0
NOME_NAME:
DB 'nome',0DH
; output a list of states to memory at 08000H
L0:
MOV AH,070H ; ZIPKEY function number ZK_VERSION
INT 179 ; fetch the version information
MOV CH,0 ; extend states count CL to CX
MOV BL,0 ; load the first state code
MOV DI,08000H ; load the output pointer
L1: ; loop here to output each state name
MOV AH,072H ; ZIPKEY function number ZK_ST_ABBR
INT 179 ; fetch the state abbreviation
STOSW ; output the abbreviation
MOV AL,' ' ; load blank
STOSB ; output an intervening blank
MOV AH,073H ; ZIPKEY function number ZK_ST_NAME
INT 179 ; output the full state name
MOV AX,0A0DH ; load CRLF
STOSW ; output CRLF to end this line
INC BL ; increment BL to the next state code
LOOP L1 ; loop to output the next state
P-13
; output to memory the list of valid zipcodes for region 474
MOV DX,474 ; load the region number
MOV DI,08000H ; load the output pointer
MOV CH,0 ; the first zipcode has bottom digits 00
L2: ; loop here to output each entry
MOV AH,075H ; ZIPKEY function number ZK_ZIP_ST
INT 179 ; check the validity of this zipcode
JC L3 ; skip if this is not a valid zipcode
MOV BL,AL ; zipcode valid: copy state code to BL
MOV AH,074H ; ZIPKEY function number ZK_ZIP_DIGITS
INT 179 ; output the zipcode digits
MOV AL,' ' ; load blank
STOSB ; output an intervening blank
CALL CITY_ST_CRLF ; output the city, state, and CRLF
L3:
INC CH ; increment the bottom 2 digits counter
CMP CH,100 ; have we completed the region?
JB L2 ; loop if not, to output the next line
; output a list of Illinois cities starting with RO
MOV DI,08000H ; load the output pointer
MOV BX,'LI' ; characters IL are reversed on the 8086
MOV AH,071H ; ZIPKEY function number ZK_ABBR_ST
INT 179 ; fetch the state code for this abbreviation
MOV BL,AL ; copy the state code to BL
PUSH CS ; push our code segment
POP DS ; set DS to our code segment
MOV SI,OFFSET RO_NAME ; point to "RO" city specification
MOV AH,078H ; ZIPKEY function number ZK_STCITY_ZIP
INT 179 ; get the list of entries for this city
JC L4 ; skip if the list was empty
CALL OUT_ENTRIES
L4:
; output a list of Nomes in the United States
MOV DI,08000H ; load the output pointer
PUSH CS ; push our code segment
POP DS ; set DS to our code segment
MOV SI,OFFSET NOME_NAME ; point to "Nome" specification
MOV BL,0 ; first state code is zero
JMP L6 ; jump into loop
L5: ; loop here for each matching state
PUSH AX ; save the state code
CALL OUT_ENTRIES ; output the entries for this state
POP BX ; restore the state code to BL
INC BX ; increment to the next state
L6:
MOV AH,079H ; ZIPKEY function number ZK_CITY_ZIP
INT 179 ; find a state with the desired city
JNC L5 ; loop if found, to make display
P-14
; set the maximum city width to 17
MOV BL,17 ; load the desired city width
MOV BH,0FFH ; code signals that we load width only
MOV AH,07CH ; ZIPKEY function number ZK_RESTORE
INT 179 ; set the city width
; save and restore ZIPKEY context
MOV AH,07BH ; ZIPKEY function number ZK_SAVE
INT 179 ; fetch the ZIPKEY context
PUSH BX ; push the context onto our stack
PUSH CX
PUSH DX
; ....
POP DX ; pop the saved context
POP CX
POP BX
MOV AH,07CH ; ZIPKEY function number ZK_RESTORE
INT 179 ; restore the ZIPKEY context
; popup a window as if the first hotkey were pressed
MOV AH,07DH ; ZIPKEY function number ZK_POPUP
MOV BL,0 ; index for the first hotkey is zero
INT 179 ; popup the ZIPKEY window
; insert keystrokes for zipcode 47401, as if alternate
; exit key F1 had been pressed
MOV DX,474 ; load the region number 474
MOV CH,01 ; load the last two digits 01
MOV BX,03B00 ; load the BIOS code for the F1 key
MOV AH,077H ; ZIPKEY function number ZK_ZIP_KEYS
INT 179 ; insert keystrokes for 47401 entry
; toggle the activation of ZIPKEY's hotkeys
MOV BL,3 ; control code for "toggle"
MOV AH,07FH ; ZIPKEY function number ZK_SWITCH
INT 179 ; toggle the activation of hotkeys
P-15
; output to DI a list of sample cities for area code 512
MOV BP,512 ; load the area code number
MOV DI,08000H ; load the output pointer
MOV DX,BP ; set DX to the area code
CALL OUT_DX3 ; output the area code
MOV BX,BP ; copy the area code to BX, for ZK_AREA_ST
MOV AH,080H ; function code for ZK_AREA_ST
INT 179 ; set AL to the state code for area code BX
JC OUT_CRLF ; exit if the area code did not exist
MOV BL,AL ; we have a state code: copy it to BL
MOV AH,073H ; function code for ZK_ST_NAME
INT 179 ; output the name of this area code's state
CALL OUT_CRLF ; output a CRLF to complete the header line
CMP DX,1000 ; was it a Canadian area code?
JAE OUT_CRLF ; skip if it was
L7: ; loop here to check each zip region
PUSH DI ; save the output pointer
ADD DI,6 ; advance pointer to the city-name column
MOV AH,07EH ; function code for ZK_REGION_CITY
INT 179 ; output the city name for this region
CMP BX,BP ; does the city have the correct area code?
MOV AX,DI ; save the end-of-line output pointer
POP DI ; restore the start-of-line output pointer
JNE L8 ; cancel the line if it wasn't our area code
PUSH AX ; we do have our area code: save end pointer
MOV AX,' ' ; load two blanks
STOSW ; output a two-blank indentation
CALL OUT_DX3 ; output the area code
POP DI ; restore the end-of-line pointer
CALL OUT_CRLF ; output the terminating CRLF
L8:
INC DX ; advance DX to the next zip region
LOOP L7 ; loop to check the next region
P-16
CITY_ST_CRLF: ; subroutine for outputting a city line
PUSH DX ; preserve register across call
MOV AH,076H ; ZIPKEY function number ZK_ZIP_CITY
INT 179 ; output the city name
MOV DX,BX ; copy the area code to DX, for output
MOV BL,AL ; copy the state code to BL
MOV AL,' ' ; load blank
STOSB ; output an intervening blank
MOV AH,072H ; ZIPKEY function number ZK_ST_ABBR
INT 179 ; fetch the state abbreviation
STOSW ; output the state abbreviation
MOV AX,'( ' ; load a space and a left paren
STOSW ; output a space and a left paren
CALL OUT_DX3 ; output the area code
DEC DI ; retract the trailing blank
MOV AL,')' ; load a right paren
STOSB ; output a right paren
POP DX ; restore clobbered register
OUT_CRLF: ; subroutine for outputting line terminator
MOV AX,0A0DH ; load CRLF
STOSW ; output CRLF
RET
OUT_DX3: ; subroutine for outputting 3-digit DX
PUSH CX ; preserve register across call
MOV CH,0FFH ; CH code suppresses the final two digits
MOV AH,074H ; function code for ZK_ZIP_DIGITS
INT 179 ; output the 3-digit code
MOV AL,' ' ; load blank
STOSB ; output a trailing blank
POP CX ; restore clobbered register
RET
P-17
OUT_ENTRIES: ; subroutine for outputting a cities-range
MOV BL,0 ; load the first entry number
L9: ; loop here to output each entry
PUSH BX ; save the entry number during output
PUSH DI ; save the starting output pointer
ADD DI,5 ; advance beyond the zipcode we will output
MOV AX,' ' ; load blanks
STOSW ; blank out the trailing range slot
STOSW ; slot plus trailing blank are 4 characters
POP DI ; restore the pointer to the line start
MOV AH,07AH ; ZIPKEY function number ZK_CASE_ZIP
INT 179 ; look up this entry
MOV BL,AL ; copy the state code to BL
CMP CL,CH ; is there only one zipcode?
JE L10 ; skip if single zipcode: slot stays blank
PUSH DI ; it is a range: save output pointer
ADD DI,3 ; advance the output pointer
MOV AH,074H ; ZIPKEY function number ZK_ZIP_DIGITS
INT 179 ; output the end-value zipcode digits
POP DI ; restore starting output pointer
ES MOV BYTE PTR [DI+5],'-' ; place the trailing hyphen
MOV CH,CL ; copy the start-value to CH
L10:
MOV AH,074H ; ZIPKEY function number ZK_ZIP_DIGITS
INT 179 ; output the start-value zipcode digits
ADD DI,4 ; advance beyond the end-value slot
CALL CITY_ST_CRLF ; output the city, state, CRLF
POP BX ; restore the entry number BL
INC BL ; increment the entry number
CMP BL,BH ; have we exhausted the entries?
JB L9 ; loop if not, to output the next entry
RET